/* @internal */
名域 ts {
    导出 接口 源映射作者_ {
        /**
         * Initialize the SourceMapWriter for a new output 文件.
         *
         * @param 文件路径 The 路径 to the generated output 文件.
         * @param 源映射文件路径 The 路径 to the output source map 文件.
         * @param 源文件或源文件集 The input source 文件 or bundle for the program.
         */
        初始化(文件路径: 文字, 源映射文件路径: 文字, 源文件或源文件集: 源文件_ | 源文件集_): 无值;

        /**
         * Reset the SourceMapWriter to an empty 状态.
         */
        重置(): 无值;

        /**
         * Set the 当前 source 文件.
         *
         * @param 源文件 The source 文件.
         */
        设置源文件(源文件: 源码映射源码_): 无值;

        /**
         * Emits a mapping.
         *
         * If the position is synthetic (未定 or a 消极的 value), no mapping will be
         * created.
         *
         * @param 首位 The position.
         */
        输出首位(首位: 数字): 无值;

        /**
         * Emits a n with possible leading and trailing source maps.
         *
         * @param 提示 The 当前 emit 上下文
         * @param n The n to emit.
         * @param 输出回调 The callback used to emit the n.
         */
        输出节点包括源映射(提示: 输出提示_, n: 节点_, 输出回调: (提示: 输出提示_, n: 节点_) => 无值): 无值;

        /**
         * Emits a 令牌 of a n n with possible leading and trailing source maps.
         *
         * @param n The n containing the 令牌.
         * @param 令牌 The 令牌 to emit.
         * @param 令牌开始首位 The 开始 首位 of the 令牌.
         * @param 输出回调 The callback used to emit the 令牌.
         */
        输出令牌包括源映射(n: 节点_, 令牌: 语法_, 作者: (s: 文字) => 无值, 令牌开始首位: 数字, 输出回调: (令牌: 语法_, 作者: (s: 文字) => 无值, 令牌开始首位: 数字) => 数字): 数字;

        /**
         * Gets the 文本 for the source map.
         */
        获取文本(): 文字 | 未定;

        /**
         * Gets the SourceMappingURL for the source map.
         */
        获取源映射URL(): 文字 | 未定;

        /**
         * Gets test data for source maps.
         */
        获取源映射数据(): 源映射数据_;
    }

    // Used for initialize lastEncodedSourceMapSpan and reset lastEncodedSourceMapSpan when updateLastEncodedAndRecordedSpans
    常量 默认已编码源映射: 源映射跨度_ = {
        输出的行: 1,
        输出的列: 1,
        源行: 1,
        源列数: 1,
        源索引: 0
    };

    导出 函数 创建源映射作者(主机: 输出主机_, 作者: 输出文本作者_): 源映射作者_ {
        常量 启用诊断信息 = 为真;
        变量 当前源文件: 源码映射源码_;
        变量 当前源文件文本: 文字;
        // Current source map 文件 and its index in the sources 列表
        变量 源映射源索引: 数字;

        // Last recorded and encoded spans
        变量 上次记录的源映射跨度: 源映射跨度_;
        变量 上次编码的源映射跨度: 源映射跨度_;
        变量 上次编码的名称索引: 数字;

        // Source map data
        变量 源映射数据: 源映射数据_;
        变量 禁用: 真假 = 为真;

        返回 {
            初始化,
            重置,
            获取源映射数据: () => 源映射数据,
            设置源文件,
            输出首位,
            输出节点包括源映射,
            输出令牌包括源映射,
            获取文本,
            获取源映射URL,
        };

        /**
         * Skips trivia such as 注释组 and white-空格_ that can optionally overriden by the source map source
         */
        函数 跳过源码杂项(首位: 数字): 数字 {
            返回 当前源文件.跳过杂项 ? 当前源文件.跳过杂项(首位) : 跳过杂项(当前源文件文本, 首位);
        }

        /**
         * Initialize the SourceMapWriter for a new output 文件.
         *
         * @param 文件路径 The 路径 to the generated output 文件.
         * @param 源映射文件路径 The 路径 to the output source map 文件.
         */
        函数 初始化(文件路径: 文字, 源映射文件路径: 文字) {
            如果 (禁用) {
                返回;
            }

            如果 (源映射数据) {
                重置();
            }

            当前源文件 = 未定!;
            当前源文件文本 = 未定!;

            // Current source map 文件 and its index in the sources 列表
            源映射源索引 = -1;

            // Last recorded and encoded spans
            上次记录的源映射跨度 = 未定!;
            上次编码的源映射跨度 = 默认已编码源映射;
            上次编码的名称索引 = 0;

            // Initialize source map data
            源映射数据 = {
                源映射文件路径: 源映射文件路径,
                Js源映射URL: 获取基文件名称(规范化斜杠(源映射文件路径))!,
                源映射文件: 获取基文件名称(规范化斜杠(文件路径))!,
                源映射源根: '',
                源映射源组: [],
                输入源文件组: [],
                源映射名称组: [],
                源映射映射组: '',
                源映射源内容: 未定,
                源映射解码映射组: []
            };

            // Normalize source root and make sure it has trailing '/' so that it can be used to combine paths with the
            // relative paths of the sources 列表 in the sourcemap
            源映射数据.源映射源根 = 规范化斜杠(源映射数据.源映射源根);
            如果 (源映射数据.源映射源根.长度 && 源映射数据.源映射源根.字符代码在(源映射数据.源映射源根.长度 - 1) !== 字符_.斜杠号_) {
                源映射数据.源映射源根 += 目录分隔符;
            }
        }

        /**
         * Reset the SourceMapWriter to an empty 状态.
         */
        函数 重置() {
            如果 (禁用) {
                返回;
            }
            当前源文件 = 未定!;
            源映射源索引 = 未定!;
            上次记录的源映射跨度 = 未定!;
            上次编码的源映射跨度 = 未定!;
            上次编码的名称索引 = 未定!;
            源映射数据 = 未定!;
        }

        // Encoding for sourcemap 跨度
        函数 编码上次记录的源映射跨度() {
            如果 (!上次记录的源映射跨度 || 上次记录的源映射跨度 === 上次编码的源映射跨度) {
                返回;
            }

            变量 前一个编码的已输出列 = 上次编码的源映射跨度.输出的列;
            // Line/Comma delimiters
            如果 (上次编码的源映射跨度.输出的行 === 上次记录的源映射跨度.输出的行) {
                // Emit 逗号_ to separate the entry
                如果 (源映射数据.源映射映射组) {
                    源映射数据.源映射映射组 += ',';
                }
            }
            否则 {
                // Emit line delimiters
                循环 (变量 编码行 = 上次编码的源映射跨度.输出的行; 编码行 < 上次记录的源映射跨度.输出的行; 编码行++) {
                    源映射数据.源映射映射组 += ';';
                }
                前一个编码的已输出列 = 1;
            }

            // 1. Relative Column 0 based
            源映射数据.源映射映射组 += base64VLQ格式化编码(上次记录的源映射跨度.输出的列 - 前一个编码的已输出列);

            // 2. Relative sourceIndex
            源映射数据.源映射映射组 += base64VLQ格式化编码(上次记录的源映射跨度.源索引 - 上次编码的源映射跨度.源索引);

            // 3. Relative sourceLine 0 based
            源映射数据.源映射映射组 += base64VLQ格式化编码(上次记录的源映射跨度.源行 - 上次编码的源映射跨度.源行);

            // 4. Relative sourceColumn 0 based
            源映射数据.源映射映射组 += base64VLQ格式化编码(上次记录的源映射跨度.源列数 - 上次编码的源映射跨度.源列数);

            // 5. Relative namePosition 0 based
            如果 (上次记录的源映射跨度.名称索引! >= 0) {
                调试_.断言(为假, 'We do not support 名称 index 右侧 now, Make sure to update updateLastEncodedAndRecordedSpans when we 开始 using this');
                源映射数据.源映射映射组 += base64VLQ格式化编码(上次记录的源映射跨度.名称索引! - 上次编码的名称索引);
                上次编码的名称索引 = 上次记录的源映射跨度.名称索引!;
            }

            上次编码的源映射跨度 = 上次记录的源映射跨度;
            源映射数据.源映射解码映射组.压入(上次编码的源映射跨度);
        }

        /**
         * Emits a mapping.
         *
         * If the position is synthetic (未定 or a 消极的 value), no mapping will be
         * created.
         *
         * @param 首位 The position.
         */
        函数 输出首位(首位: 数字) {
            如果 (禁用 || 位置是合成的(首位)) {
                返回;
            }

            如果 (启用诊断信息) {
                性能.标记('beforeSourcemap');
            }

            常量 源行首位 = 获取位置的行和字符(当前源文件, 首位);

            // Convert the location to be one-based.
            源行首位.行++;
            源行首位.字符++;

            常量 输出的行 = 作者.获取行();
            常量 输出的列 = 作者.获取列();

            // If this location wasn't recorded or the location in source is going backwards, record the 跨度
            如果 (!上次记录的源映射跨度 ||
                上次记录的源映射跨度.输出的行 !== 输出的行 ||
                上次记录的源映射跨度.输出的列 !== 输出的列 ||
                (上次记录的源映射跨度.源索引 === 源映射源索引 &&
                    (上次记录的源映射跨度.源行 > 源行首位.行 ||
                        (上次记录的源映射跨度.源行 === 源行首位.行 && 上次记录的源映射跨度.源列数 > 源行首位.字符)))) {

                // Encode the 最后的 recordedSpan before assigning new
                编码上次记录的源映射跨度();

                // New 跨度
                上次记录的源映射跨度 = {
                    输出的行: 输出的行,
                    输出的列: 输出的列,
                    源行: 源行首位.行,
                    源列数: 源行首位.字符,
                    源索引: 源映射源索引
                };
            }
            否则 {
                // Take the new 首位 instead since there is no change in emittedLine and column since 最后的 location
                上次记录的源映射跨度.源行 = 源行首位.行;
                上次记录的源映射跨度.源列数 = 源行首位.字符;
                上次记录的源映射跨度.源索引 = 源映射源索引;
            }

            如果 (启用诊断信息) {
                性能.标记('afterSourcemap');
                性能.度量('Source Map', 'beforeSourcemap', 'afterSourcemap');
            }
        }

        /**
         * Emits a n with possible leading and trailing source maps.
         *
         * @param 提示 A hint as to the intended usage of the n.
         * @param n The n to emit.
         * @param 输出回调 The callback used to emit the n.
         */
        函数 输出节点包括源映射(提示: 输出提示_, n: 节点_, 输出回调: (提示: 输出提示_, n: 节点_) => 无值) {
            如果 (禁用) {
                返回 输出回调(提示, n);
            }

            如果 (n) {
                常量 输出节点 = n.输出节点;
                常量 输出标志 = 输出节点 && 输出节点.标志;
                常量 范围 = 输出节点 && 输出节点.源映射范围;
                常量 { 首位, 尾位 } = 范围 || n;
                变量 源 = 范围 && 范围.源;
                常量 旧源 = 当前源文件;
                如果 (源 === 旧源) 源 = 未定;

                如果 (源) 设置源文件(源);

                如果 (n.种类 !== 语法_.不输出语句_
                    && (输出标志! & 输出标志_.无前导源映射_) === 0
                    && 首位 >= 0) {
                    输出首位(跳过源码杂项(首位));
                }

                如果 (源) 设置源文件(旧源);

                如果 (输出标志! & 输出标志_.无嵌套源映射_) {
                    禁用 = 为真;
                    输出回调(提示, n);
                    禁用 = 为假;
                }
                否则 {
                    输出回调(提示, n);
                }

                如果 (源) 设置源文件(源);

                如果 (n.种类 !== 语法_.不输出语句_
                    && (输出标志! & 输出标志_.无尾随源映射_) === 0
                    && 尾位 >= 0) {
                    输出首位(尾位);
                }

                如果 (源) 设置源文件(旧源);
            }
        }

        /**
         * Emits a 令牌 of a n with possible leading and trailing source maps.
         *
         * @param n The n containing the 令牌.
         * @param 令牌 The 令牌 to emit.
         * @param tokenStartPos The 开始 首位 of the 令牌.
         * @param 输出回调 The callback used to emit the 令牌.
         */
        函数 输出令牌包括源映射(n: 节点_, 令牌: 语法_, 作者: (s: 文字) => 无值, 令牌首位: 数字, 输出回调: (令牌: 语法_, 作者: (s: 文字) => 无值, 令牌开始首位: 数字) => 数字) {
            如果 (禁用) {
                返回 输出回调(令牌, 作者, 令牌首位);
            }

            常量 输出节点 = n && n.输出节点;
            常量 输出标志 = 输出节点 && 输出节点.标志;
            常量 范围 = 输出节点 && 输出节点.令牌源映射范围 && 输出节点.令牌源映射范围[令牌];

            令牌首位 = 跳过源码杂项(范围 ? 范围.首位 : 令牌首位);
            如果 ((输出标志! & 输出标志_.无令牌前导源映射_) === 0 && 令牌首位 >= 0) {
                输出首位(令牌首位);
            }

            令牌首位 = 输出回调(令牌, 作者, 令牌首位);

            如果 (范围) 令牌首位 = 范围.尾位;
            如果 ((输出标志! & 输出标志_.无令牌尾随源映射_) === 0 && 令牌首位 >= 0) {
                输出首位(令牌首位);
            }

            返回 令牌首位;
        }

        /**
         * Set the 当前 source 文件.
         *
         * @param 源文件 The source 文件.
         */
        函数 设置源文件(源文件: 源码映射源码_) {
            如果 (禁用) {
                返回;
            }

            当前源文件 = 源文件;
            当前源文件文本 = 当前源文件.文本;

            // Add the 文件 to tsFilePaths
            // If sourceroot option: Use the relative 路径 corresponding to the common directory 路径
            // otherwise source locations relative to map 文件 location
            常量 源目录路径 = 主机.获取公共源目录();

            常量 源 = 获取相对路径到目录或URL(源目录路径,
                当前源文件.文件名,
                主机.获取当前目录(),
                主机.获取规范文件名称,
                /*isAbsolutePathAnUrl*/ 为真);

            源映射源索引 = 源映射数据.源映射源组.索引位于(源!);
            如果 (源映射源索引 === -1) {
                源映射源索引 = 源映射数据.源映射源组.长度;
                源映射数据.源映射源组.压入(源!);

                // The one that can be used from program to get the actual source 文件
                源映射数据.输入源文件组.压入(当前源文件.文件名);

                源映射数据.源映射源内容!.压入(当前源文件.文本);
            }
        }

        /**
         * Gets the 文本 for the source map.
         */
        函数 获取文本():文字 | 未定 {
            如果 (禁用) {
                返回;
            }

            编码上次记录的源映射跨度();

            返回 JSON.序列化({
                version: 3,
                file: 源映射数据.源映射文件,
                sourceRoot: 源映射数据.源映射源根,
                sources: 源映射数据.源映射源组,
                names: 源映射数据.源映射名称组,
                mappings: 源映射数据.源映射映射组,
                sourcesContent: 源映射数据.源映射源内容,
            });
        }

        /**
         * Gets the SourceMappingURL for the source map.
         */
        函数 获取源映射URL():文字 | 未定 {
            如果 (禁用) {
                返回;
            }
            返回 源映射数据.Js源映射URL;
        }
    }

    常量 base64Chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';

    函数 base64格式化编码(inValue: 数字) {
        如果 (inValue < 64) {
            返回 base64Chars.字符在(inValue);
        }

        抛出 类型错误_(inValue + ': not a 64 based value');
    }

    函数 base64VLQ格式化编码(inValue: 数字) {
        // Add a new least significant bit that has the sign of the value.
        // if 消极的 number the least significant bit that gets added to the number has value 1
        // else least significant bit value that gets added is 0
        // eg. -1 changes to binary : 01 [1] => 3
        //     +1 changes to binary : 01 [0] => 2
        如果 (inValue < 0) {
            inValue = ((-inValue) << 1) + 1;
        }
        否则 {
            inValue = inValue << 1;
        }

        // Encode 5 bits at a time starting from least significant bits
        变量 encodedStr = '';
        运行 {
            变量 currentDigit = inValue & 31; // 11111
            inValue = inValue >> 5;
            如果 (inValue > 0) {
                // There are still more digits to decode, set the msb (6th bit)
                currentDigit = currentDigit | 32;
            }
            encodedStr = encodedStr + base64格式化编码(currentDigit);
        } 判断 (inValue > 0);

        返回 encodedStr;
    }
}